\section{Módulo RISCO para o LLVM}

\begin{frame}
\textbf{Módulo RISCO para o LLVM}
\end{frame}

\begin{frame}
\frametitle{Módulo RISCO-LLVM}
\begin{itemize}
  \item Habilita o desenvolvimento de software para o RISCO em linguagem de alto
  nível
  \item Tradução da LLVM-IR
  \item Baseado nos backends MIPS e ARM (LOPES, 2009)
  \item Biblioteca carregada pelo LLVM em tempo de execução
  \item Integrado ao Clang: C, C++, Object-C e Object-C++
\end{itemize}
\end{frame}

\begin{frame}
\frametitle{Decisões de projeto}
\begin{itemize}
  \item Instruções de ponto-flutuante da LLVM-IR
  \item Multiplicação, divisão e resto: \texttt{MulDivTransform}
  \item Definição da interface binária
  \item Especificação do backend LLVM
\end{itemize}
\end{frame}

\begin{frame}
\frametitle{RISCO32}
\begin{itemize}
  \item Convenção de chamada, baseada na MIPS32
  \item Organização do programa em tempo de execução
  \item Camada de compatibilidade entre binários
\end{itemize}
\end{frame}


\begin{frame}
\frametitle{RISCO32}
\framesubtitle{Registradores}
\footnotesize
\begin{table}[htb]
\begin{center}
\begin{tabular}{ c | c | c }
  \textbf{Nome no risco-as} & \textbf{Código} & \textbf{Classe} \\
  \hline
  
  \texttt{\$zero} & R00 & (N/A) \\
  \texttt{\$psw} & R01 & caller-saved \\
  \texttt{\$v0} & R02 & caller-saved \\
  \texttt{\$a0 - \$a4} & R03 - R07 & caller-saved \\
  \texttt{\$t0 - \$t9} & R08 - R17 & caller-saved \\
  \texttt{\$s0 - \$s7} & R18 - R25 & callee-saved \\
  (N/A) & R26 - R28 & (N/A) \\
  \texttt{\$fp} & R29 & callee-saved \\
  \texttt{\$pc} & R31 & (N/A) \\
\end{tabular}
\end{center}
\caption{Convenções de uso para os registradores RISCO}
\end{table}
\end{frame}


\begin{frame}
\frametitle{RISCO32}
\framesubtitle{Organização da pilha}
\begin{figure}[htb]
  \includegraphics[scale=0.45]{images/stack-frame}
  \textsf{\tiny \caption{Registro de ativação de uma rotina}}
\end{figure}
\end{frame}


\begin{frame}
\frametitle{RISCO-LLVM}
\begin{itemize}
  \item Biblioteca dinâmica agregada ao código do LLVM
  \item Pequenas modificações fora da biblioteca
  \item Serve ao gerador de código independente do alvo
  \item Módulos independentes em C++ (TableGen)
\end{itemize}
\end{frame}

\begin{frame}
\frametitle{TargetMachine}
\begin{itemize}
  \item Ponto de acesso central
  \item Informa layout dos dados
  \item Modelos do processador
  \item Registro do backend
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{RegisterInfo e CallingConv}
\begin{itemize}
  \item Descrição da interface binária em TableGen
\end{itemize}
\begin{columns}[t]
\column{.5\textwidth}
\tiny
\begin{verbatim}
class RiscoReg<bits<5> num, string n>
    : Register<n>
{
  field bits<5> Num;
  let Num = num;
}
let Namespace = "Risco" in
{
  ...
  def A0   : RiscoReg< 4, "$a0">;
  def A1   : RiscoReg< 5, "$a1">;
  def A2   : RiscoReg< 6, "$a2">;
  def A3   : RiscoReg< 7, "$a3">;
  ...
}
\end{verbatim}
\footnotesize
\begin{itemize}
  \item RISCORegisterInfo
\end{itemize}


\column{.5\textwidth}
\tiny
\begin{verbatim}
def RetCC_RISCO32 : CallingConv<[
  CCIfType<[i32], CCAssignToReg<[V0]>>,
  CCAssignToStack<4, 4>
]>;

def CC_RISCO32 : CallingConv<[
  CCIfType<[i8, i16], CCPromoteToType<i32>>,
  CCIfType<[i32], CCAssignToReg<[A0, A1, A2, A3, A4]>>,
  CCAssignToStack<4, 4>
]>;
\end{verbatim}
\footnotesize
\begin{itemize}
  \item RISCOCallingConv
\end{itemize}

\end{columns}
\end{frame}


\begin{frame}
\frametitle{InstrInfo}
\begin{itemize}
  \item Especificação das instruções da plataforma para o LLVM (TableGen e C++)
  \item Instruções \emph{polimórficas}: \texttt{ADDrr}, \texttt{ADDri}
  \item Para cada instrução:
  \begin{itemize}
    \item Nome
    \item Template na linguagem de montagem
    \item Nó gerado no SelectionDAG
    \item Padrão de seleção no SelectionDAG
  \end{itemize}
  \item Refatoração em termos dos tipos de instrução
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{InstrInfo}
\footnotesize
\begin{verbatim}
let isCommutable = 1 in
class ArithR<bits<6> op, bits<6> func,
             string instr_asm, SDNode OpNode>:
  Instr<op, func,
        (outs CPURegs:$dst), (ins CPURegs:$b, CPURegs:$c),
        instr_asm,
        [(set CPURegs:$dst, (OpNode CPURegs:$b, CPURegs:$c))]>;
      
def ADDrr : ArithR<0x00, 0x00, "add $dst, $b, $c", add>;
\end{verbatim}
\normalsize
\begin{itemize}
  \item Exemplo de especificação de uma instrução no RISCOInstrInfo
\end{itemize}
\end{frame}


\begin{frame}[fragile]
\frametitle{InstrInfo}
\footnotesize
\begin{verbatim}
def SLT     : SetCC_R<0x00, 0x2a,
  "cmp ($b, $c)\n\t"
  "and $dst, $$psw, LT_MASK\n\t"
  "srl $dst, $dst, LT_POS",
  setlt>;
      
def LB      : LoadM<0x20,
  "ld $dst, $addr\n\t"
  "sll $dst, $dst, 24\n\t"
  "sra $dst, $dst, 24",
  sextloadi8>;
      
def BEQ     : CBranch<0x04,
  "cmp ($a, $b)\n\t"
  "jmpeq $offset",
  seteq>;
\end{verbatim}
\begin{itemize}
  \item Exemplos de instruções compostas
\end{itemize}
\end{frame}







\begin{frame}[fragile]
\frametitle{RISCO-C}
% \framesubtitle{Driver do compilador}
\begin{columns}[t]
\column{.5\textwidth}
\scriptsize
\begin{verbatim}
#include "risco/iostream.hpp"
using namespace std;

int main(void) {
  int n;
  cin >> n;
  cout << n+1 << endl;
  return 0;
}
\end{verbatim}
\footnotesize
\begin{itemize}
  \item Driver do compilador
  \begin{enumerate}
    \item clang
    \item opt
    \item llc
    \item risco-peep-opt
    \item risco-as
  \end{enumerate}
\end{itemize}

\column{.5\textwidth}
\scriptsize
\begin{verbatim}
#include "risco/ext.h"
#include "risco/stdlib.h"
        .global main
        .text
main:
        add $sp, $sp, -24
        sr read_int
        nop
        add $a0, $v0, 1
        sr print_int
        nop
        add $a0, $zero, 10
        sr print_char
        nop
        add $v0, $zero, 0
        add $sp, $sp, 24
        ret
        nop
\end{verbatim}
\footnotesize
% \begin{itemize}
%   \item Código RISCO
% \end{itemize}

\end{columns}
\end{frame}


\begin{frame}
\frametitle{Verificação do compilador}
\begin{itemize}
  \item Extremamente difícil garantir a \alert{corretude} de um compilador
  moderno
  \item É mais fácil garantir um certo nível de qualidade com \alert{testes}
  \begin{itemize}
    \item Cenários reais de compilação
    \item Testes de regressão a cada bug
  \end{itemize}
  \item Foi utilizado um processo inspirado no DDT
\end{itemize}
\end{frame}

\begin{frame}
\frametitle{Verificação do compilador}
\framesubtitle{Processo de desenvolvimento}
\footnotesize
\begin{enumerate}
  \item Cria um conjunto de testes: um programa mínimo em C
  \item Compila todos os programas do conjunto
  \item \alert{Erro interno}: conserta e retorna ao passo 2
  \item Executa todos os programas. Existem entrada e saída pré-definidas, no
  estilo ICPC. Usa o método da votação.
  \item Saída incorreta: \alert{código incorreto}. Conserta e retorna ao passo 2
  \item Conjunto estabilizado. Duas opções: aumentar a complexidade de um dos
  testes ou criar outro programa
  \item Retorna ao passo 2
\end{enumerate}
\end{frame}


\begin{frame}
\frametitle{Verificação do compilador}
\begin{itemize}
  \item Resultado: o processo foi fundamental para garantir a qualidade do
  compilador
  \item Encontra falhas rapidamente
  \item Uso do simulador \texttt{risco-sim} foi imprescindível
  \item 43 programas em C e C++
  \begin{itemize}
    \item 35 são soluções para problemas do juiz online da Universidad de
    Valladolid
    \item Exercitam diversas funcionalidades: manipulação de strings,
    algoritmos em grafos, programação dinâmica, etc.
  \end{itemize}
\end{itemize}
\end{frame}
